//package Multijugador;
//
//import java.io.Serializable;
//import java.util.Iterator;
//
//import android.app.Activity;
//import android.content.Context;
//import android.graphics.Canvas;
//import android.graphics.Color;
//import android.graphics.Paint;
//import android.graphics.Rect;
//import android.graphics.Typeface;
//import android.util.Log;
//import android.view.*;
//import android.widget.Toast;
///**
// * Esta clase es la encargada de la generacion de los tableros, de manera manual y grafica en caso de que sean jugadores y automatica en caso de que sea el de la Maquina.
// * @author Georthik
// * @version x.x
// */
//public class mViewMulti extends View implements Serializable{
//	MensajeroMulti mens;
//	Activity act;
//	Casilla matCasillas[][] = new Casilla[10][10];
//	Barco arrBarcos[] = new Barco[5];
//	Context con = null;
//	Barco barcoDibujado;
//	float scale = 0;
//	Paint whitePaint;
//	int ancho = 0;
//	int alto = 0;
//	int matriz[][] = new int[10][10];
//	int matrizAux[][] = new int[10][10];
//	Rect btnGirar;
//	int casillax;
//	int casillay;
//	int casillaxAux=11;
//	int casillayAux=11;
//	int anchocua = 0;
//	int moviendox;
//	int moviendoy;
//	boolean fdraw = true;
//	boolean fdrawJugando = true;
//	boolean cambios = false;
//	boolean barcoPuesto = false;
//	int barcoMoviendo = 0;
//	boolean moviendoBarco = false;
//	boolean enCuadricula = false;
//	boolean error = false;
//	boolean jugando=false;
//	boolean orientacion = true;
//	int contadorBarcosPuestos = 0;
//	private int barcosMaquinaHundidos;
//	private Toast toast;
//	private int duracion=Toast.LENGTH_SHORT;
//
//	/**
//	 * Constructor para la generacion de un "tablero" manual, inicializa las matrices numericas y crea un paint auxiliar para obtener la escala de la pantalla.
//	 * @param actividad actividad actual.
//	 * @param mens la clase intermediaria, el Mensajero.
//	 */
//	public mViewMulti(Activity actividad,MensajeroMulti mens) {
//		super(actividad.getApplicationContext());
//		Paint whitePaint;
//		act=actividad;
//		con = act.getApplicationContext();
//		this.mens=mens;
//		setKeepScreenOn(true);
//		scale = con.getResources().getDisplayMetrics().density;
//		whitePaint = new Paint();
//		whitePaint.setAntiAlias(true);
//		whitePaint.setColor(Color.WHITE);
//		whitePaint.setStyle(Paint.Style.STROKE);
//		whitePaint.setTextAlign(Paint.Align.LEFT);
//		whitePaint.setTextSize(scale * 15);
//		for (int i = 0; i < 10; i++) {
//			for (int j = 0; j < 10; j++) {
//				matriz[i][j] = 0;
//				matrizAux[i][j] = 0;
//			}
//		}
//	}
//
//
//	/**
//	 * Es el metodo encargado de dibujar la pantalla la primera vez que se ejecuta esta vista y cada vez que se interactua con ella.
//	 * Es donde se trata la generacion manual del "tablero" de juego. dibuja la matriz de casillas que componen el tablero, un boton para seleccionar la orientacion del barco a colocar,
//	 * el cuerpo del barco a colocar que se colocara mediante arrastre del mismo y un texto indicando la orientacion actual del barco. Maneja las comprobaciones necesarias para
//	 * que los barcos colocados esten dentro de la cuadricula del tablero y no se superpongan a otros barcos. Tambien obliga a respetar el espacio minimo entre barcos.
//	 * @Override	
//	 */
//	protected void onDraw(Canvas canvas) {
//		canvas.drawRGB(0, 0, 0);
//		ancho = canvas.getWidth();
//		alto = canvas.getHeight();
//		anchocua = ancho / 10;
//		Paint paint = new Paint();
//		paint.setTextSize(20);
//		Paint paint2 = new Paint();
//		paint2.setTextSize(20);
//		paint2.setTypeface(Typeface.DEFAULT_BOLD);
//		paint2.setARGB(255, 255,255,255);
//		Paint paintlinea1 = new Paint();
//		paintlinea1.setARGB(255, 255, 255, 255);
//
//		int filaact = 0;
//		int yMaxTabla;
//		int yLibre;
//		int margen;
//		int yBarco;
//		if(fdraw){
//			moviendox=ancho;
//			moviendoy=alto;
//			fdraw=false;
//		}
//		for (int f = 0; f < 10; f++) {
//			for (int c = 0; c < 10; c++) {
//				Casilla aux = new Casilla(c * anchocua, filaact, anchocua);
//				matCasillas[f][c] = aux;
//				paint.setARGB(153, 204, 204, 204);
//				canvas.drawRect(c * anchocua, filaact, c * anchocua + anchocua- 2, filaact + anchocua - 2, paint);
//				canvas.drawLine(c * anchocua, filaact, c * anchocua + anchocua,filaact, paintlinea1);
//				canvas.drawLine(c * anchocua + anchocua - 1, filaact, c* anchocua + anchocua - 1, filaact + anchocua,paintlinea1);
//			}
//			filaact = filaact + anchocua;
//		}
//		yMaxTabla = matCasillas[9][0].getY() + anchocua;
//		yLibre = alto - yMaxTabla;
//		margen = anchocua - (int) (anchocua / 2);
//		yBarco = alto - yLibre + margen;
//		// Boton de girar el barco
//		paint.setARGB(250, 200, 50, 200);
//		btnGirar = new Rect(margen, yBarco, anchocua + margen * 2, yBarco+ anchocua);
//		canvas.drawRect(btnGirar, paint);
//		// barco
//
//		barcoDibujado = new Barco(margen * 3 + anchocua, yBarco, anchocua,getLongitud());
//		paint.setARGB(215, 50, 200, 50);
//		canvas.drawRect(margen * 3 + anchocua, yBarco, (margen * 3 + anchocua)+ anchocua * getLongitud(), yBarco + anchocua, paint);
//		
//		// orientacion
//		if(orientacion){
//			canvas.drawText("Posicion: Horizontal", margen, yBarco+anchocua+margen*2, paint2);
//		}else{
//			canvas.drawText("Posicion: Vertical", margen, yBarco+anchocua+margen*2, paint2);
//		}
//		if (moviendoBarco) {
//			if(casillax!=casillaxAux || casillay!=casillayAux){
//				for (int i = 0; i < 10; i++) {
//					for (int j = 0; j < 10; j++) {
//						matriz[i][j] = matrizAux[i][j];
//					}
//				}
//				error = false;
//				try {
//					Barco movAux = new Barco(casillax, casillay, orientacion,getLongitud(), matriz, contadorBarcosPuestos + 1);
//
//				} catch (Exception e) {
//					error = true;					
//				}
//			}
//			if(!error){
//				paint.setARGB(215, 50, 200, 50);
//				}else{
//					paint.setARGB(215, 250, 50, 50);
//				}
//				if (orientacion) {
//					canvas.drawRect(moviendox, moviendoy, moviendox + anchocua* getLongitud(), moviendoy + anchocua, paint);
//				} else {
//					canvas.drawRect(moviendox, moviendoy, moviendox + anchocua,moviendoy + anchocua * getLongitud(), paint);
//				}
//				casillaxAux=casillax;
//				casillayAux=casillay;
//		}
//		if (barcoPuesto) {
//			contadorBarcosPuestos--;
//			arrBarcos[contadorBarcosPuestos] = new Barco(casillax, casillay,moviendox, moviendoy, orientacion, getLongitud(), matriz,contadorBarcosPuestos + 1);
//			contadorBarcosPuestos++;
//			barcoPuesto = false;
//			for (int i = 0; i < 10; i++) {
//				for (int j = 0; j < 10; j++) {
//					matrizAux[i][j] = matriz[i][j];
//				}
//			}
//			if(contadorBarcosPuestos==5){
//  				jugando=true;
//  				if(mens.soyServidor){
//  					mens.enviarTabJugadorServer(this);
//  					act.setContentView(mens);
//  				}else{
//  					mens.enviarTabJugadorClient(this);
//  					act.setContentView(mens);
//  				}
//				invalidate();
//			}
//		}
//		
//		try {
//			paint.setARGB(255, 235, 195, 30);
//			for (int i = 0; i < 5; i++) {
//				if (arrBarcos[i].getOrientacion()) {
//					canvas.drawRect(arrBarcos[i].getX(),arrBarcos[i].getY(),arrBarcos[i].getX() + anchocua* arrBarcos[i].getLongitud(),arrBarcos[i].getY() + anchocua, paint);
//				} else {
//					canvas.drawRect(arrBarcos[i].getX(), arrBarcos[i].getY(),arrBarcos[i].getX() + anchocua, arrBarcos[i].getY()+ anchocua * arrBarcos[i].getLongitud(),paint);
//				}
//			}
//		} catch (Exception e) {}
//	}
//
//	/**
//	 * Es el metodo encargado de la interaccion con la pantalla. Es utilizado para reconocer cuando se ha tocado dentro de la superficie de un barco, cuando se esta moviendo y cuando se suelta para su posterior colocacion
//	 * Tambien controla la interaccion con el boton de girar los barcos.
//	 * @Override 
//	 */
//	public synchronized boolean onTouchEvent(MotionEvent me) {
//		int eventaction = me.getAction();
//		int x = (int) me.getX();
//		int y = (int) me.getY();
//		switch (eventaction) {
//		case MotionEvent.ACTION_DOWN:
//			if (barcoDibujado.dentro(x, y)) {
//				moviendoBarco = true;
//			}
//			if (btnGirar.contains(x, y)) {
//				orientacion = !orientacion;
//			}
//			break;
//		case MotionEvent.ACTION_MOVE:
//			if(!jugando){
//				if (moviendoBarco) {
//					moviendoy = (int) (y - anchocua / 0.8);
//					if (x > ancho / 2) {
//						moviendox = (int) (x + anchocua / 1.2);
//					} else {
//						moviendox = (int) (x - (anchocua / 1.2));
//					}
//					for (int i = 0; i < 10; i++) {
//						for (int j = 0; j < 10; j++) {
//							if (matCasillas[i][j].dentro(moviendox, moviendoy)) {
//								moviendox = matCasillas[i][j].getX();
//								moviendoy = matCasillas[i][j].getY();
//								casillax = i;
//								casillay = j;
//								i = 9;
//								j = 9;
//								enCuadricula = true;
//							} else {
//								enCuadricula = false;
//							}
//						}
//					}
//				}
//			}
//			break;
//		case MotionEvent.ACTION_UP:
//			if(!jugando){
//				if (moviendoBarco) {
//					if (enCuadricula && !error) {
//						barcoPuesto = true;
//						contadorBarcosPuestos++;
//						enCuadricula = false;
//					}
//					moviendoBarco = false;
//				}
//				break;
//			}
//		}
//		invalidate();
//		return true;
//	}
//
//	/**
//	 * Devuelve la longitud a tener en cuenta segun el barco actual, los barcos se colocaran por orden empezando por el mas pequeno y acabando por el mayor.
//	 * @return
//	 */
//	public int getLongitud() {
//		int longitud = 0;
//		switch (contadorBarcosPuestos) {
//		case 0:
//			longitud = 2;
//			break;
//		case 1:
//		case 2:
//			longitud = 3;
//			break;
//		case 3:
//			longitud = 4;
//			break;
//		case 4:
//			longitud = 5;
//			break;
//		}
//		return longitud;
//	}
//
//	/**
//	 * Este metodo se encarga de comprobar el contenido de la matriz numerica basandose en las coordenadas recibidas.
//	 * @param x 
//	 * @param y
//	 * @return devuelve 0 en caso de que sea agua, 1 si se ha tocado algun barco y 2 si se ha hundido dicho barco. 
//	 */
//	public synchronized int probarCoor(int x, int y){	
//		int num=-1;
//		if(matriz[x][y]==0||matriz[x][y]==9){
//			matCasillas[x][y].setAgua(true);
//			num=0;//agua
//		}else{
//			int i=matriz[x][y]-1;
//			arrBarcos[i].tocado();
//			num=1;//tocado
//			if(arrBarcos[i].estaHundido()){
//				num=2;//hundido
//			}
//		}
//		return num;
//	}
//	
//	public boolean finJuego(){
//		for(int i=0;i<10;i++){
//			for(int j=0;j<10;j++){
//				if(matriz[i][j]!=0&&matriz[i][j]!=9){
//					return false;
//				}
//			}
//		}
//		return true;
//	}
//}